Concurrent Cube-and-Conquer - (Poster Presentation)

Satisfiability solvers targeting industrial instances are currently almost always based on conflict-driven clause learning (CDCL) [5]. This technique can successfully solve very large instances. Yet on small, hard problems lookahead solvers [3] often perform better by applying much more reasoning in each search node and then recursively splitting the search space until a solution is found. The cube-and-conquer (CC) approach [4] has shown that the two techniques can be combined, resulting in better performance particularly for very hard instances. The key insight is that lookahead solvers can be used to partition the search space into subproblems (called cubes) that are easy for a CDCL solver to solve. By first partitioning (cube phase) and then solving each cube (conquer phase), some instances can be solved within hours rather than days. This cubeand-conquer approach, particularly the conquer phase, is also easy to parallelize. The challenge to make this technique work in practice lies in developing effective heuristics to determine when to stop partitioning and start solving. The current heuristics already give strong results for very hard instances, but are far from optimal and require some fine tuning to work well with instances of different difficulty. For example, applying too much partitioning might actually result in a considerable increase of run time for easy instances. On the other hand, applying not enough partitioning reduces the benefits of cube-and-conquer. The most important problem in developing an improved heuristic is that in the partitioning phase no information is available about how well the CDCL solver will perform on a cube. In CC’s heuristics, performance of CDCL is assumed to be similar to that of lookahead: if lookahead refutes a cube, CDCL is expected to be able to refute similar cubes fast, and if CDCL would solve a cube fast, lookahead is expected to be able to refute it fast too. However, due to the different nature of lookahead and CDCL, this is not always true. To improve cutoff heuristics, we propose concurrent cube-and-conquer (CCC): an online approach that runs the cube and conquer phases concurrently. Whenever the lookahead solver makes a new decision, this decision is sent to the CDCL solver, which adds it as an assumption [2]. If CDCL refutes a cube fast, it will refute it before lookahead makes another decision. This naturally cuts off easy branches, so that the cutoff heuristic is no longer necessary. Although this basic version of CCC already achieves speedups, it can be improved further by applying a (slightly different) cutoff heuristic. This heuristic